package com.cjc.mylibrary.menu.lib;

import java.lang.reflect.Method;

import android.app.Activity;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.Display;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;

import com.cjc.mylibrary.R;
import com.cjc.mylibrary.menu.lib.CustomViewAbove.OnPageChangeListener;

/**
 * 
 ***************************************************** 
 * <hr>
 * <dt><span class="strong">类功能简介:</span></dt>
 * <dd>SlidingMenu开源库</dd>
 * <dt><span class="strong">创建时间:</span></dt>
 * <dd>2014-8-21 下午3:08:03</dd>
 * <dt><span class="strong">公司:</span></dt>
 * <dd>CorpIt</dd>
 * 
 * @author aa1000777 - Email:aa1000777@qq.com
 ***************************************************** 
 */
public class SlidingMenu extends RelativeLayout {

    public static final int SLIDING_WINDOW = 0;
    public static final int SLIDING_CONTENT = 1;

    /**
     * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
     * to be opened with a swipe gesture on the screen's margin
     */
    public static final int TOUCHMODE_MARGIN = 0;

    /**
     * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
     * to be opened with a swipe gesture anywhere on the screen
     */
    public static final int TOUCHMODE_FULLSCREEN = 1;

    /**
     * Constant value for use with setTouchModeAbove(). Denies the SlidingMenu
     * to be opened with a swipe gesture
     */
    public static final int TOUCHMODE_NONE = 2;

    /**
     * Constant value for use with setMode(). Puts the menu to the left of the
     * content.
     */
    public static final int LEFT = 0;

    /**
     * Constant value for use with setMode(). Puts the menu to the right of the
     * content.
     */
    public static final int RIGHT = 1;

    /**
     * Constant value for use with setMode(). Puts menus to the left and right
     * of the content.
     */
    public static final int LEFT_RIGHT = 2;

    private CustomViewAbove mViewAbove;

    private CustomViewBehind mViewBehind;

    private OnOpenListener mOpenListener;

    private OnCloseListener mCloseListener;

    /**
     * The listener interface for receiving onOpen events. The class that is
     * interested in processing a onOpen event implements this interface, and
     * the object created with that class is registered with a component using
     * the component's <code>addOnOpenListener<code> method. When
     * the onOpen event occurs, that object's appropriate
     * method is invoked
     */
    public interface OnOpenListener {

	/**
	 * On open.
	 */
	public void onOpen();
    }

    /**
     * The listener interface for receiving onOpened events. The class that is
     * interested in processing a onOpened event implements this interface, and
     * the object created with that class is registered with a component using
     * the component's <code>addOnOpenedListener<code> method. When
     * the onOpened event occurs, that object's appropriate
     * method is invoked.
     * 
     * @see OnOpenedEvent
     */
    public interface OnOpenedListener {

	/**
	 * On opened.
	 */
	public void onOpened();
    }

    /**
     * The listener interface for receiving onClose events. The class that is
     * interested in processing a onClose event implements this interface, and
     * the object created with that class is registered with a component using
     * the component's <code>addOnCloseListener<code> method. When
     * the onClose event occurs, that object's appropriate
     * method is invoked.
     * 
     * @see OnCloseEvent
     */
    public interface OnCloseListener {

	/**
	 * On close.
	 */
	public void onClose();
    }

    /**
     * The listener interface for receiving onClosed events. The class that is
     * interested in processing a onClosed event implements this interface, and
     * the object created with that class is registered with a component using
     * the component's <code>addOnClosedListener<code> method. When
     * the onClosed event occurs, that object's appropriate
     * method is invoked.
     * 
     * @see OnClosedEvent
     */
    public interface OnClosedListener {

	/**
	 * On closed.
	 */
	public void onClosed();
    }

    /**
     * The Interface CanvasTransformer.
     */
    public interface CanvasTransformer {

	/**
	 * Transform canvas.
	 * 
	 * @param canvas
	 *            the canvas
	 * @param percentOpen
	 *            the percent open
	 */
	public void transformCanvas(Canvas canvas, float percentOpen);
    }

    /**
     * Instantiates a new SlidingMenu.
     * 
     * @param context
     *            the associated Context
     */
    public SlidingMenu(Context context) {
	this(context, null);
    }

    /**
     * Instantiates a new SlidingMenu and attach to Activity.
     * 
     * @param activity
     *            the activity to attach slidingmenu
     * @param slideStyle
     *            the slidingmenu style
     */
    public SlidingMenu(Activity activity, int slideStyle) {
	this(activity, null);
	this.attachToActivity(activity, slideStyle);
    }

    /**
     * Instantiates a new SlidingMenu.
     * 
     * @param context
     *            the associated Context
     * @param attrs
     *            the attrs
     */
    public SlidingMenu(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
    }

    /**
     * Instantiates a new SlidingMenu.
     * 
     * @param context
     *            the associated Context
     * @param attrs
     *            the attrs
     * @param defStyle
     *            the def style
     */
    public SlidingMenu(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);

	LayoutParams behindParams = new LayoutParams(LayoutParams.FILL_PARENT,
		LayoutParams.FILL_PARENT);
	mViewBehind = new CustomViewBehind(context);
	addView(mViewBehind, behindParams);
	LayoutParams aboveParams = new LayoutParams(LayoutParams.FILL_PARENT,
		LayoutParams.FILL_PARENT);
	aboveParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
	mViewAbove = new CustomViewAbove(context);
	addView(mViewAbove, aboveParams);
	// register the CustomViewBehind2 with the CustomViewAbove
	mViewAbove.setCustomViewBehind(mViewBehind);
	mViewBehind.setCustomViewAbove(mViewAbove);
	mViewAbove.setOnPageChangeListener(new OnPageChangeListener() {
	    public static final int POSITION_OPEN = 0;
	    public static final int POSITION_CLOSE = 1;

	    public void onPageScrolled(int position, float positionOffset,
		    int positionOffsetPixels) {
	    }

	    public void onPageSelected(int position) {
		if (position == POSITION_OPEN && mOpenListener != null) {
		    mOpenListener.onOpen();
		} else if (position == POSITION_CLOSE && mCloseListener != null) {
		    mCloseListener.onClose();
		}
	    }
	});

	// now style everything!
	TypedArray ta = context.obtainStyledAttributes(attrs,
		R.styleable.SlidingMenu);
	// set the above and behind views if defined in xml
	int mode = ta.getInt(R.styleable.SlidingMenu_mode, LEFT);
	setMode(mode);
	int viewAbove = ta.getResourceId(R.styleable.SlidingMenu_viewAbove, -1);
	if (viewAbove != -1) {
	    setContent(viewAbove);
	} else {
	    setContent(new FrameLayout(context));
	}
	int viewBehind = ta.getResourceId(R.styleable.SlidingMenu_viewBehind,
		-1);
	if (viewBehind != -1) {
	    setMenu(viewBehind);
	} else {
	    setMenu(new FrameLayout(context));
	}
	int touchModeAbove = ta.getInt(R.styleable.SlidingMenu_touchModeAbove,
		TOUCHMODE_MARGIN);
	setTouchModeAbove(touchModeAbove);

	int offsetBehind = (int) ta.getDimension(
		R.styleable.SlidingMenu_behindOffset, -1);
	int widthBehind = (int) ta.getDimension(
		R.styleable.SlidingMenu_behindWidth, -1);
	if (offsetBehind != -1 && widthBehind != -1)
	    throw new IllegalStateException(
		    "Cannot set both behindOffset and behindWidth for a SlidingMenu");
	else if (offsetBehind != -1)
	    setBehindOffset(offsetBehind);
	else if (widthBehind != -1)
	    setBehindWidth(widthBehind);
	else
	    setBehindOffset(0);
	float scrollOffsetBehind = ta.getFloat(
		R.styleable.SlidingMenu_behindScrollScale, 0.33f);
	setBehindScrollScale(scrollOffsetBehind);
	int shadowRes = ta.getResourceId(
		R.styleable.SlidingMenu_shadowDrawable, -1);
	if (shadowRes != -1) {
	    setShadowDrawable(shadowRes);
	}
	int shadowWidth = (int) ta.getDimension(
		R.styleable.SlidingMenu_shadowWidth, 0);
	setShadowWidth(shadowWidth);
	boolean fadeEnabled = ta.getBoolean(
		R.styleable.SlidingMenu_behindFadeEnabled, true);
	setFadeEnabled(fadeEnabled);
	float fadeDeg = ta.getFloat(R.styleable.SlidingMenu_behindFadeDegree,
		0.66f);
	setFadeDegree(fadeDeg);
	boolean selectorEnabled = ta.getBoolean(
		R.styleable.SlidingMenu_selectorEnabled, false);
	setSelectorEnabled(selectorEnabled);
	int selectorRes = ta.getResourceId(
		R.styleable.SlidingMenu_selectorDrawable, -1);
	if (selectorRes != -1)
	    setSelectorDrawable(selectorRes);
	ta.recycle();
    }

    public void attachToActivity(Activity activity, int slideStyle) {
	if (slideStyle != SLIDING_WINDOW && slideStyle != SLIDING_CONTENT)
	    throw new IllegalArgumentException(
		    "slideStyle must be either SLIDING_WINDOW or SLIDING_CONTENT");

	if (getParent() != null)
	    throw new IllegalStateException(
		    "This SlidingMenu appears to already be attached");

	// get the window background
	TypedArray a = activity.getTheme().obtainStyledAttributes(
		new int[] { android.R.attr.windowBackground });
	int background = a.getResourceId(0, 0);
	a.recycle();

	switch (slideStyle) {
	case SLIDING_WINDOW:
	    ViewGroup decor = (ViewGroup) activity.getWindow().getDecorView();
	    ViewGroup decorChild = (ViewGroup) decor.getChildAt(0);
	    // save ActionBar themes that have transparent assets
	    decorChild.setBackgroundResource(background);
	    decor.removeView(decorChild);
	    setContent(decorChild);
	    decor.addView(this);
	    break;
	case SLIDING_CONTENT:
	    View content = activity.findViewById(R.id.slidingmenu_layout);
	    ViewGroup contentParent = (ViewGroup) activity
		    .findViewById(R.id.slidingmenu_main_layout);
	    contentParent.removeView(content);
	    contentParent.addView(this, new LayoutParams(
		    LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
	    setContent(content);
	    // save people from having transparent backgrounds
	    if (content.getBackground() == null)
		content.setBackgroundResource(background);
	    break;
	}

    }

    /**
     * Set the above view content from a layout resource. The resource will be
     * inflated, adding all top-level views to the above view.
     * 
     * @param res
     *            the new content
     */
    public void setContent(int res) {
	setContent(LayoutInflater.from(getContext()).inflate(res, null));
    }

    /**
     * Set the above view content to the given View.
     * 
     * @param view
     *            The desired content to display.
     */
    public void setContent(View view) {
	mViewAbove.setContent(view);
	showContent();
    }

    /**
     * Retrieves the current content.
     * 
     * @return the current content
     */
    public View getContent() {
	return mViewAbove.getContent();
    }

    /**
     * Set the behind view (menu) content from a layout resource. The resource
     * will be inflated, adding all top-level views to the behind view.
     * 
     * @param res
     *            the new content
     */
    public void setMenu(int res) {
	setMenu(LayoutInflater.from(getContext()).inflate(res, null));
    }

    /**
     * Set the behind view (menu) content to the given View.
     * 
     * @param view
     *            The desired content to display.
     */
    public void setMenu(View v) {
	mViewBehind.setContent(v);
    }

    /**
     * Retrieves the current menu.
     * 
     * @return the current menu
     */
    public View getMenu() {
	return mViewBehind.getContent();
    }

    /**
     * Set the secondary behind view (right menu) content from a layout
     * resource. The resource will be inflated, adding all top-level views to
     * the behind view.
     * 
     * @param res
     *            the new content
     */
    public void setSecondaryMenu(int res) {
	setSecondaryMenu(LayoutInflater.from(getContext()).inflate(res, null));
    }

    /**
     * Set the secondary behind view (right menu) content to the given View.
     * 
     * @param view
     *            The desired content to display.
     */
    public void setSecondaryMenu(View v) {
	mViewBehind.setSecondaryContent(v);
	// mViewBehind.invalidate();
    }

    /**
     * Retrieves the current secondary menu (right).
     * 
     * @return the current menu
     */
    public View getSecondaryMenu() {
	return mViewBehind.getSecondaryContent();
    }

    /**
     * Sets the sliding enabled.
     * 
     * @param b
     *            true to enable sliding, false to disable it.
     */
    public void setSlidingEnabled(boolean b) {
	mViewAbove.setSlidingEnabled(b);
    }

    /**
     * Checks if is sliding enabled.
     * 
     * @return true, if is sliding enabled
     */
    public boolean isSlidingEnabled() {
	return mViewAbove.isSlidingEnabled();
    }

    /**
     * Sets which side the SlidingMenu should appear on.
     * 
     * @param mode
     *            must be either SlidingMenu.LEFT or SlidingMenu.RIGHT
     */
    public void setMode(int mode) {
	if (mode != LEFT && mode != RIGHT && mode != LEFT_RIGHT) {
	    throw new IllegalStateException(
		    "SlidingMenu mode must be LEFT, RIGHT, or LEFT_RIGHT");
	}
	mViewBehind.setMode(mode);
    }

    /**
     * Returns the current side that the SlidingMenu is on.
     * 
     * @return the current mode, either SlidingMenu.LEFT or SlidingMenu.RIGHT
     */
    public int getMode() {
	return mViewBehind.getMode();
    }

    /**
     * Sets whether or not the SlidingMenu is in static mode (i.e. nothing is
     * moving and everything is showing)
     * 
     * @param b
     *            true to set static mode, false to disable static mode.
     */
    public void setStatic(boolean b) {
	if (b) {
	    setSlidingEnabled(false);
	    mViewAbove.setCustomViewBehind(null);
	    mViewAbove.setCurrentItem(1);
	    // mViewBehind.setCurrentItem(0);
	} else {
	    mViewAbove.setCurrentItem(1);
	    // mViewBehind.setCurrentItem(1);
	    mViewAbove.setCustomViewBehind(mViewBehind);
	    setSlidingEnabled(true);
	}
    }

    /**
     * Opens the menu and shows the menu view.
     */
    public void showMenu() {
	showMenu(true);
    }

    /**
     * Opens the menu and shows the menu view.
     * 
     * @param animate
     *            true to animate the transition, false to ignore animation
     */
    public void showMenu(boolean animate) {
	mViewAbove.setCurrentItem(0, animate);
    }

    /**
     * Opens the menu and shows the secondary menu view. Will default to the
     * regular menu if there is only one.
     */
    public void showSecondaryMenu() {
	showSecondaryMenu(true);
    }

    /**
     * Opens the menu and shows the secondary (right) menu view. Will default to
     * the regular menu if there is only one.
     * 
     * @param animate
     *            true to animate the transition, false to ignore animation
     */
    public void showSecondaryMenu(boolean animate) {
	mViewAbove.setCurrentItem(2, animate);
    }

    /**
     * Closes the menu and shows the above view.
     */
    public void showContent() {
	showContent(true);
    }

    /**
     * Closes the menu and shows the above view.
     * 
     * @param animate
     *            true to animate the transition, false to ignore animation
     */
    public void showContent(boolean animate) {
	mViewAbove.setCurrentItem(1, animate);
    }

    /**
     * Toggle the SlidingMenu. If it is open, it will be closed, and vice versa.
     */
    public void toggle() {
	toggle(true);
    }

    /**
     * Toggle the SlidingMenu. If it is open, it will be closed, and vice versa.
     * 
     * @param animate
     *            true to animate the transition, false to ignore animation
     */
    public void toggle(boolean animate) {
	if (isMenuShowing()) {
	    showContent(animate);
	} else {
	    showMenu(animate);
	}
    }

    /**
     * Checks if is the behind view showing.
     * 
     * @return Whether or not the behind view is showing
     */
    public boolean isMenuShowing() {
	return mViewAbove.getCurrentItem() == 0
		|| mViewAbove.getCurrentItem() == 2;
    }

    /**
     * Gets the behind offset.
     * 
     * @return The margin on the right of the screen that the behind view
     *         scrolls to
     */
    public int getBehindOffset() {
	return ((RelativeLayout.LayoutParams) mViewBehind.getLayoutParams()).rightMargin;
    }

    /**
     * Sets the behind offset.
     * 
     * @param i
     *            The margin, in pixels, on the right of the screen that the
     *            behind view scrolls to.
     */
    public void setBehindOffset(int i) {
	// RelativeLayout.LayoutParams params =
	// ((RelativeLayout.LayoutParams)mViewBehind.getLayoutParams());
	// int bottom = params.bottomMargin;
	// int top = params.topMargin;
	// int left = params.leftMargin;
	// params.setMargins(left, top, i, bottom);
	mViewBehind.setWidthOffset(i);
    }

    /**
     * Sets the behind offset.
     * 
     * @param resID
     *            The dimension resource id to be set as the behind offset. The
     *            menu, when open, will leave this width margin on the right of
     *            the screen.
     */
    public void setBehindOffsetRes(int resID) {
	int i = (int) getContext().getResources().getDimension(resID);
	setBehindOffset(i);
    }

    /**
     * Sets the above offset.
     * 
     * @param i
     *            the new above offset, in pixels
     */
    public void setAboveOffset(int i) {
	mViewAbove.setAboveOffset(i);
    }

    /**
     * Sets the above offset.
     * 
     * @param resID
     *            The dimension resource id to be set as the above offset.
     */
    public void setAboveOffsetRes(int resID) {
	int i = (int) getContext().getResources().getDimension(resID);
	setAboveOffset(i);
    }

    /**
     * Sets the behind width.
     * 
     * @param i
     *            The width the Sliding Menu will open to, in pixels
     */
    @SuppressWarnings("deprecation")
    public void setBehindWidth(int i) {
	int width;
	Display display = ((WindowManager) getContext().getSystemService(
		Context.WINDOW_SERVICE)).getDefaultDisplay();
	try {
	    Class<?> cls = Display.class;
	    Class<?>[] parameterTypes = { Point.class };
	    Point parameter = new Point();
	    Method method = cls.getMethod("getSize", parameterTypes);
	    method.invoke(display, parameter);
	    width = parameter.x;
	} catch (Exception e) {
	    width = display.getWidth();
	}
	setBehindOffset(width - i);
    }

    /**
     * Sets the behind width.
     * 
     * @param res
     *            The dimension resource id to be set as the behind width
     *            offset. The menu, when open, will open this wide.
     */
    public void setBehindWidthRes(int res) {
	int i = (int) getContext().getResources().getDimension(res);
	setBehindWidth(i);
    }

    /**
     * Gets the behind scroll scale.
     * 
     * @return The scale of the parallax scroll
     */
    public float getBehindScrollScale() {
	return mViewBehind.getScrollScale();
    }

    /**
     * Sets the behind scroll scale.
     * 
     * @param f
     *            The scale of the parallax scroll (i.e. 1.0f scrolls 1 pixel
     *            for every 1 pixel that the above view scrolls and 0.0f scrolls
     *            0 pixels)
     */
    public void setBehindScrollScale(float f) {
	if (f < 0 && f > 1)
	    throw new IllegalStateException(
		    "ScrollScale must be between 0 and 1");
	mViewBehind.setScrollScale(f);
    }

    /**
     * Sets the behind canvas transformer.
     * 
     * @param t
     *            the new behind canvas transformer
     */
    public void setBehindCanvasTransformer(CanvasTransformer t) {
	mViewBehind.setCanvasTransformer(t);
    }

    /**
     * Gets the touch mode above.
     * 
     * @return the touch mode above
     */
    public int getTouchModeAbove() {
	return mViewAbove.getTouchMode();
    }

    /**
     * Controls whether the SlidingMenu can be opened with a swipe gesture.
     * Options are {@link #TOUCHMODE_MARGIN TOUCHMODE_MARGIN},
     * {@link #TOUCHMODE_FULLSCREEN TOUCHMODE_FULLSCREEN}, or
     * {@link #TOUCHMODE_NONE TOUCHMODE_NONE}
     * 
     * @param i
     *            the new touch mode
     */
    public void setTouchModeAbove(int i) {
	if (i != TOUCHMODE_FULLSCREEN && i != TOUCHMODE_MARGIN
		&& i != TOUCHMODE_NONE) {
	    throw new IllegalStateException(
		    "TouchMode must be set to either"
			    + "TOUCHMODE_FULLSCREEN or TOUCHMODE_MARGIN or TOUCHMODE_NONE.");
	}
	mViewAbove.setTouchMode(i);
    }

    /**
     * Sets the shadow drawable.
     * 
     * @param resId
     *            the resource ID of the new shadow drawable
     */
    public void setShadowDrawable(int resId) {
	setShadowDrawable(getContext().getResources().getDrawable(resId));
    }

    /**
     * Sets the shadow drawable.
     * 
     * @param d
     *            the new shadow drawable
     */
    public void setShadowDrawable(Drawable d) {
	mViewBehind.setShadowDrawable(d);
    }

    /**
     * Sets the secondary (right) shadow drawable.
     * 
     * @param resId
     *            the resource ID of the new shadow drawable
     */
    public void setSecondaryShadowDrawable(int resId) {
	setSecondaryShadowDrawable(getContext().getResources().getDrawable(
		resId));
    }

    /**
     * Sets the secondary (right) shadow drawable.
     * 
     * @param d
     *            the new shadow drawable
     */
    public void setSecondaryShadowDrawable(Drawable d) {
	mViewBehind.setSecondaryShadowDrawable(d);
    }

    /**
     * Sets the shadow width.
     * 
     * @param resId
     *            The dimension resource id to be set as the shadow width.
     */
    public void setShadowWidthRes(int resId) {
	setShadowWidth((int) getResources().getDimension(resId));
    }

    /**
     * Sets the shadow width.
     * 
     * @param pixels
     *            the new shadow width, in pixels
     */
    public void setShadowWidth(int pixels) {
	mViewBehind.setShadowWidth(pixels);
    }

    /**
     * Enables or disables the SlidingMenu's fade in and out
     * 
     * @param b
     *            true to enable fade, false to disable it
     */
    public void setFadeEnabled(boolean b) {
	mViewBehind.setFadeEnabled(b);
    }

    /**
     * Sets how much the SlidingMenu fades in and out. Fade must be enabled, see
     * {@link #setFadeEnabled(boolean) setFadeEnabled(boolean)}
     * 
     * @param f
     *            the new fade degree, between 0.0f and 1.0f
     */
    public void setFadeDegree(float f) {
	mViewBehind.setFadeDegree(f);
    }

    /**
     * Enables or disables whether the selector is drawn
     * 
     * @param b
     *            true to draw the selector, false to not draw the selector
     */
    public void setSelectorEnabled(boolean b) {
	mViewAbove.setSelectorEnabled(true);
    }

    /**
     * Sets the selected view. The selector will be drawn here
     * 
     * @param v
     *            the new selected view
     */
    public void setSelectedView(View v) {
	mViewAbove.setSelectedView(v);
    }

    /**
     * Sets the selector drawable.
     * 
     * @param res
     *            a resource ID for the selector drawable
     */
    public void setSelectorDrawable(int res) {
	mViewAbove.setSelectorBitmap(BitmapFactory.decodeResource(
		getResources(), res));
    }

    /**
     * Sets the selector drawable.
     * 
     * @param b
     *            the new selector bitmap
     */
    public void setSelectorBitmap(Bitmap b) {
	mViewAbove.setSelectorBitmap(b);
    }

    /**
     * Sets the OnOpenListener. {@link OnOpenListener#onOpen()
     * OnOpenListener.onOpen()} will be called when the SlidingMenu is opened
     * 
     * @param listener
     *            the new OnOpenListener
     */
    public void setOnOpenListener(OnOpenListener listener) {
	// mViewAbove.setOnOpenListener(listener);
	mOpenListener = listener;
    }

    /**
     * Sets the OnCloseListener. {@link OnCloseListener#onClose()
     * OnCloseListener.onClose()} will be called when the SlidingMenu is closed
     * 
     * @param listener
     *            the new setOnCloseListener
     */
    public void setOnCloseListener(OnCloseListener listener) {
	// mViewAbove.setOnCloseListener(listener);
	mCloseListener = listener;
    }

    /**
     * Sets the OnOpenedListener. {@link OnOpenedListener#onOpened()
     * OnOpenedListener.onOpened()} will be called after the SlidingMenu is
     * opened
     * 
     * @param listener
     *            the new OnOpenedListener
     */
    public void setOnOpenedListener(OnOpenedListener listener) {
	mViewAbove.setOnOpenedListener(listener);
    }

    /**
     * Sets the OnClosedListener. {@link OnClosedListener#onClosed()
     * OnClosedListener.onClosed()} will be called after the SlidingMenu is
     * closed
     * 
     * @param listener
     *            the new OnClosedListener
     */
    public void setOnClosedListener(OnClosedListener listener) {
	mViewAbove.setOnClosedListener(listener);
    }

    public static class SavedState extends BaseSavedState {

	private final boolean mBehindShowing;

	public SavedState(Parcelable superState, boolean isBehindShowing) {
	    super(superState);
	    mBehindShowing = isBehindShowing;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see android.view.AbsSavedState#writeToParcel(android.os.Parcel, int)
	 */
	public void writeToParcel(Parcel out, int flags) {
	    super.writeToParcel(out, flags);
	    out.writeByte(mBehindShowing ? (byte) 1 : 0);
	}

	public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
	    public SavedState createFromParcel(Parcel in) {
		return new SavedState(in);
	    }

	    public SavedState[] newArray(int size) {
		return new SavedState[size];
	    }
	};

	private SavedState(Parcel in) {
	    super(in);
	    mBehindShowing = in.readByte() != 0;
	}
    }

    /*
     * (non-Javadoc)
     * 
     * @see android.view.View#onSaveInstanceState()
     */
    @Override
    protected Parcelable onSaveInstanceState() {
	Parcelable superState = super.onSaveInstanceState();
	SavedState ss = new SavedState(superState, isMenuShowing());
	return ss;
    }

    /*
     * (non-Javadoc)
     * 
     * @see android.view.View#onRestoreInstanceState(android.os.Parcelable)
     */
    @Override
    protected void onRestoreInstanceState(Parcelable state) {
	if (!(state instanceof SavedState)) {
	    try {
		super.onRestoreInstanceState(state);
	    } catch (Exception e) {
		// TODO: handle exception
		state = null;
	    }
	    return;
	}
	if (state != null) {
	    SavedState ss = (SavedState) state;
	    try {
		super.onRestoreInstanceState(ss.getSuperState());
	    } catch (Exception e) {
		// TODO: handle exception
	    }

	    if (ss.mBehindShowing) {
		showMenu();
	    } else {
		showContent();
	    }
	}
    }

    /*
     * (non-Javadoc)
     * 
     * @see android.view.ViewGroup#fitSystemWindows(android.graphics.Rect)
     */
    @Override
    protected boolean fitSystemWindows(Rect insets) {
	int leftPadding = insets.left;
	int rightPadding = insets.right;
	int topPadding = insets.top;
	int bottomPadding = insets.bottom;
	setPadding(leftPadding, topPadding, rightPadding, bottomPadding);
	return true;
    }

}